import ipywidgets as widgets

from IPython.display import display, Markdown, HTML, Javascript, clear_output, Image, Markdown

​

# from IPython.display import display, 

​

# Define JavaScript code

js_code = """

    function toggleCodeCells() {

        var codeCells = document.querySelectorAll('div.input');

        codeCells.forEach(function(cell) {

            if (cell.style.display !== 'none') {

                cell.style.display = 'none';

            } else {

                cell.style.display = 'block';

            }

        });

    }

"""

​

# Display the JavaScript code

display(HTML(f"<script>{js_code}</script>"))

​

# Create button and set its attributes

button = widgets.Button(description="Toggle Code Cells", layout=widgets.Layout(width='250px'))

​

# Define function to call the JavaScript function

def toggle_code_cells(button):

    display(Javascript("toggleCodeCells();"))

​

# Assign the function to the button's on_click event

button.on_click(toggle_code_cells)

​

# Display the button

display(button)

​

from ProxiPal import *

import qgrid

​

# Check for an eds > txt export

eds2txt_match_list, eds2txt_match_dict = find_matched_filenames(base_path, read_export = True)

# Check for a csv file with the same name as the eds file

eds2csv_match_list, eds2csv_match_dict = find_matched_filenames(base_path, native_format = '.eds', export_format = '.csv', read_export = True)

# Review matched filenames

df_pivot = review_matched_filenames(eds2txt_match_dict, eds2csv_match_dict)

# Create a df_pivot without the path_key column for display purposes

df_without_path_key = df_pivot.drop(columns="path_key")

​

# Define column options and definitions

col_options = {'width': 100}

col_defs = {

    'index': {'width': col_options['width'] / 15},

    'experiment': {'width': col_options['width'] / 1.3},

    'eds filename': {'width': 3 * col_options['width']},

    'txt': {'width': col_options['width'] / 4},

    'csv': {'width': col_options['width'] / 4},

    'analysis': {'width': col_options['width'] / 2.4},

}

​

# Grid options: disable addition and deletion of rows

grid_options = {

    'enableColumnReorder': True,

    'enableTextSelectionOnCells': True,

    'editable': False,

    'autoEdit': False,

    'explicitInitialization': True,

    'maxVisibleRows': 15,

    'minVisibleRows': 8,

    'sortable': True,

    'filterable': True,

    'highlightSelectedCell': False,

    'highlightSelectedRow': True

}

​

def display_qgrid_table_rev(button):

    # Create qgrid widget

    qgrid_widget = qgrid.show_grid(df_without_path_key, 

                                show_toolbar=False,  # disables toolbar

                                grid_options=grid_options,  # pass grid options

                                column_options=col_options, 

                                column_definitions=col_defs)

    # Hide the index column

    qgrid_widget.layout = widgets.Layout(overflow='hidden')

    qgrid_widget._update_df()

    # Display the widget

    clear_output()

    print("Data files reviewed on: ", datetime.now().strftime("%A %d/%m/%y %H:%M"))

    display(button_box_rev)

    display(qgrid_widget)

​

def display_pandas_table_rev(button):

    clear_output()

    print("Data files reviewed on: ", datetime.now().strftime("%A %d/%m/%y %H:%M"))

    display(button_box_rev)

    pd.set_option('display.max_rows', None)

    display(df_without_path_key)

​

# Create buttons

button_qgrid_rev = widgets.Button(description="Qgrid Checklist", layout=widgets.Layout(width='250px'))

button_pandas_rev = widgets.Button(description="Pandas Checklist", layout=widgets.Layout(width='250px'))

​

# Connect buttons to functions

button_qgrid_rev.on_click(display_qgrid_table_rev)

button_pandas_rev.on_click(display_pandas_table_rev)

​

# Create a horizontal box with your buttons

button_box_rev = widgets.HBox([button_qgrid_rev, button_pandas_rev])

​

# Display the box

display(button_box_rev)

​

import warnings

​

# Suppress all warnings

warnings.filterwarnings('ignore')

​

# Column names of interest

columns_of_interest = ['filepath_txt', 'Kit_#', 'InstrumentType', 'ExperimentRunStartTime',

                       'QuantificationCycleMethod', 'Stage/CyclewhereAnalysisisperformed',

                       'Chemistry', 'PassiveReference', 'BlockType', 'InstrumentSerialNumber']

​

# Create input text field

style = {'description_width': 'initial'}

input_text = widgets.IntText(description='Select experiment index to analyze:', value=9999, style=style)

​

# Create a button

button_params = widgets.Button(description='Link CSV & EDS data',

                               layout=widgets.Layout(width='250px'))

​

# Define your function

def pandas_link_params(path_key):

    # Assuming the function ProxiPal.create_data_metatable is already defined

    meta_list = create_data_metatable(eds2txt_match_dict, eds2csv_match_dict, path_key)

​

    # Calibration columns

    calibration_columns = ['CalibrationBackgroundisexpired', 'CalibrationPureDyeROXisexpired',

                           'CalibrationPureDyeSYBRisexpired', 'CalibrationRNasePisexpired',

                           'CalibrationROIisexpired', 'CalibrationUniformityisexpired']

​

    # Initialize a new DataFrame

    new_df = pd.DataFrame(columns=['Parameter', 'Status'])

​

    # Populate the new DataFrame

    for col in columns_of_interest:

        if col in meta_list[0].columns:

            unique_values = meta_list[0][col].dropna().unique()  # Get unique values excluding NaNs

            unique_values_str = ', '.join(map(str, unique_values))  # Convert to string and join with commas

            new_row = pd.DataFrame({'Parameter': [col], 'Status': [unique_values_str]})

            new_df = pd.concat([new_df, new_row], ignore_index=True)

        else:

            print(f"Column '{col}' not found in the DataFrame.")

​

    # Calibration check

    calibration_status = []

    for col in calibration_columns:

        if (meta_list[0][col] != 'No').any():  # If any value in the column is not 'No'

            calibration_status.append(col.replace('Calibration', '').replace('isexpired', ''))

    if len(calibration_status) == 0:

        new_row = pd.DataFrame({'Parameter': ['Calibration Check'], 'Status': ['OK']})

        new_df = pd.concat([new_df, new_row], ignore_index=True)

    else:

        status_str = ', '.join(calibration_status)

        new_row = pd.DataFrame({'Parameter': ['Calibration Check'],

                                'Status': ['Calibration expired: ' + status_str]})

        new_df = pd.concat([new_df, new_row], ignore_index=True)

​

    display(new_df.style.set_properties(subset=['Status'], **{'width': '650px'}))

​

# Define what happens when the button is clicked

def button_link_params(b):

    # Disable the button

    button_params.disabled = True

    # Fetch the path_key from df_pivot based on input_text value

    path_key = df_pivot.at[input_text.value, 'path_key']

    pandas_link_params(path_key)

    print("CSV & EDS Link Complete:", datetime.now().strftime("%A %d/%m/%y %H:%M"))

​

# Set the on_button_clicked function to be called when the button is clicked

button_params.on_click(button_link_params)

​

# Create a horizontal box with the text field and the button

hbox = widgets.HBox([input_text, button_params])

​

# Display the horizontal box

display(hbox)

​

def show_plan(button):

    # Disable the button

    button_plan.disabled = True

    #     Use the input_text value from the previous cell

    input = input_text.value

    exports_path = Path(data_folder / df_pivot['experiment'][input] / df_pivot['analysis'][input] / "exports")

    metatable = pd.read_csv(exports_path / "metatable.csv")

​

    unique_values = metatable["experiment_plan"].unique().tolist()

    list_of_strings = [f"{i+1}. {value}" for i, value in enumerate(unique_values[0].split('\n'))]

​

    display(Markdown('\n'.join(list_of_strings)))

​

button_plan = widgets.Button(description="Show Experiment Plans", layout=widgets.Layout(width='250px'))

button_plan.on_click(show_plan)

display(button_plan)

​

def display_jpegs(button):

    # Disable the button

    button_jpegs.disabled = True

    input = input_text.value

    experiment_folder = Path(data_folder / df_pivot['experiment'][input] / df_pivot['analysis'][input])

    amp_plot = experiment_folder / 'Amplification Plot.jpg'

    melt_plot = experiment_folder / 'Melt Curve Plot.jpg'

    if amp_plot.is_file():

        display(Image(filename=amp_plot))

    else:

        print("Amplification Plot.jpg not found!")

​

    if melt_plot.is_file():

        display(Image(filename=melt_plot))

    else:

        print("Melt Curve Plot.jpg not found!")

    print("Plots displayed on: ", datetime.now().strftime("%A %d/%m/%y %H:%M"))

​

# Create a button

button_jpegs = widgets.Button(description="Display qPCR Plots", layout=widgets.Layout(width='250px'))

​

# Assign the function to the button's on_click event

button_jpegs.on_click(display_jpegs)

​

# Display the button

display(button_jpegs)

​

# Create a second button

button_lin_reg = widgets.Button(description='Apply Linear Regression',

                         layout=widgets.Layout(width='250px'))

​

# Define the function to run when the second button is clicked

def apply_lin_reg(b):

    # Disable the button

    button_lin_reg.disabled = True

#   Use the input_text value from the previous cell

    input = input_text.value

    path = Path(data_folder / df_pivot['experiment'][input] / df_pivot['analysis'][input] / "exports" / "metatable.csv")

    metatable = pd.read_csv(path)

    std_calc_dict = calc_metatable_std_lin_reg(metatable)

    print("Standards calculated: ", datetime.now().strftime("%A %d/%m/%y %H:%M"))

​

# Set the on_button2_clicked function to be called when the second button is clicked

button_lin_reg.on_click(apply_lin_reg)

​

​

# Display the second button

display(button_lin_reg)

# Create a button

button_show_standards = widgets.Button(description="Display Standards", 

                        layout=widgets.Layout(width='250px'))

​

def process_csv_files(folder):

    # Ensure the folder is a Path object

    folder = Path(folder)

​

    # Initialize an empty dictionary

    csv_dict = {}

​

    # Iterate over the files in the folder

    for filename in folder.iterdir():

        # If the filename contains the substring "py_std" and ends with ".csv"

        if "py_std" in filename.name and filename.suffix == ".csv":

            # Read the CSV file into a DataFrame and add it to the dictionary

            csv_dict[filename.name] = pd.read_csv(filename)

​

    # Iterate over the list ['1', '2', '3', '4']

    for number in ['1', '2', '3', '4']:

        # Construct the filename

        plot_filename = f"py_std{number}_plot_table.csv"

        # If the filename is in the dictionary

        if plot_filename in csv_dict:

            # Run the function plot_LinReg with the corresponding DataFrame

            plot_LinReg(csv_dict[plot_filename], 500, 320)

            # Print PCR efficiency

            pcr_eff_values = csv_dict[plot_filename]['py_PCReff'].unique()

            pcr_eff_values_string = ', '.join(map(lambda x: str(x) + '%', pcr_eff_values))

            print("PCR efficiency:", pcr_eff_values_string)

        table_filename = f"py_std{number}_report_table.csv"

        if table_filename in csv_dict:

            display(csv_dict[table_filename])

​

# Define a function to be called when the button is clicked

def show_standards(event):

    # Disable the button

    button_show_standards.disabled = True

    # Substitute 'your_folder_path' with the path to your folder

    exports_path = Path(data_folder / df_pivot['experiment'][input_text.value] / df_pivot['analysis'][input_text.value] / "exports")

    process_csv_files(exports_path)

    print("Data displayed on: ", datetime.now().strftime("%A %d/%m/%y %H:%M"))

​

# Attach the function to the button

button_show_standards.on_click(show_standards)

​

# Display the button

display(button_show_standards)

​

# Create the buttons

button_qgrid_samples = widgets.Button(description="Qgrid Sample Table", layout=widgets.Layout(width='250px'))

button_pandas_samples = widgets.Button(description="Pandas Sample Table", layout=widgets.Layout(width='250px'))

​

# Define the data display function for Qgrid Sample Table

def process_and_display_dataframe(event):

    input_val = input_text.value

    exports_path = Path(data_folder / df_pivot['experiment'][input_val] / df_pivot['analysis'][input_val] / "exports")

    # Fetch sample report table

    sample_report_table = pd.read_csv(exports_path / 'sample_report_table.csv')

    # Clear previous output

    clear_output()

    # Display the Qgrid table

    print('Data displayed is available at: \n' + str(exports_path / 'sample_report_table.csv'))

    display(widgets.HBox([button_qgrid_samples, button_pandas_samples]))

    display(qgrid.show_grid(sample_report_table, show_toolbar=False))

​

# Define the data display function for Pandas Sample Table

def display_pandas_dataframe(event):

    input_val = input_text.value

    exports_path = Path(data_folder / df_pivot['experiment'][input_val] / df_pivot['analysis'][input_val] / "exports")

    # Fetch sample report table

    sample_report_table = pd.read_csv(exports_path / 'sample_report_table.csv')

    # Clear previous output

    clear_output()

    # Display the Pandas table

    print('Data displayed is available at: \n' + str(exports_path / 'sample_report_table.csv'))

    display(widgets.HBox([button_qgrid_samples, button_pandas_samples]))

    pd.set_option('display.max_rows', None)

    display(sample_report_table)

​

# Assign the event handlers to the buttons

button_qgrid_samples.on_click(process_and_display_dataframe)

button_pandas_samples.on_click(display_pandas_dataframe)

​

# Display the buttons

display(widgets.HBox([button_qgrid_samples, button_pandas_samples]))

​

# Create the buttons

button_qgrid_well = widgets.Button(description="Qgrid Well Table", layout=widgets.Layout(width='250px'))

button_pandas_well = widgets.Button(description="Pandas Well Table", layout=widgets.Layout(width='250px'))

​

# Define the data display function for Qgrid Well Table

def display_qgrid_well_table(event):

    input_val = input_text.value

    exports_path = Path(data_folder / df_pivot['experiment'][input_val] / df_pivot['analysis'][input_val] / "exports")

    py_metatable = pd.read_csv(exports_path / 'py_metatable.csv')

    well_table = py_metatable[['position', 'target', 'usr_ignore','ct','py_mean_ct',  'tm', 'rep_id', 'dilution', 'usr_raw_ng/L', 'py_raw_ng/L', 

                               'py_raw_recovery', 'py_mean_ng/L']]

    # Clear previous output

    clear_output()

    # Display the Qgrid table

    print('Data displayed is available at: \n' + str(exports_path / 'py_metatable.csv'))

    display(widgets.HBox([button_qgrid_well, button_pandas_well]))

    display(qgrid.show_grid(well_table, show_toolbar=False))

​

# Define the data display function for Pandas Well Table

def display_pandas_well_table(event):

    input_val = input_text.value

    exports_path = Path(data_folder / df_pivot['experiment'][input_val] / df_pivot['analysis'][input_val] / "exports")

    py_metatable = pd.read_csv(exports_path / 'py_metatable.csv')

    well_table = py_metatable[['position', 'target', 'usr_ignore','ct','py_mean_ct',  'tm', 'rep_id', 'dilution', 'usr_raw_ng/L', 'py_raw_ng/L', 

                               'py_raw_recovery', 'py_mean_ng/L', 'calibrator']]

    # Clear previous output

    clear_output()

    # Display the Pandas table

    print('Data displayed is available at: \n' + str(exports_path / 'py_metatable.csv'))

    display(widgets.HBox([button_qgrid_well, button_pandas_well]))

    pd.set_option('display.max_rows', None)

    display(well_table)

​

# Assign the event handlers to the buttons

button_qgrid_well.on_click(display_qgrid_well_table)

button_pandas_well.on_click(display_pandas_well_table)

​

# Display the buttons

display(widgets.HBox([button_qgrid_well, button_pandas_well]))

​